﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class OdDbDatabase : OdDbObject
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdDbDatabase(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdDbDatabase_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdDbDatabase obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdDbDatabase()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_OdDbDatabase(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public virtual OdResult subGetClassID(IntPtr pClsid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDatabase_subGetClassID(this.swigCPtr, pClsid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdDbDatabase cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_cast(OdRxObject.getCPtr(pObj));
			OdDbDatabase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDatabase_desc(), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDatabase_isA(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDatabase_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdDbDatabase createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_createObject();
			OdDbDatabase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbHostAppServices appServices()
		{
			OdDbHostAppServices result = (OdDbHostAppServices)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDatabase_appServices(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void initialize(MeasurementValue measurement)
		{
			TD_DbPINVOKE.OdDbDatabase_initialize__SWIG_0(this.swigCPtr, (int)measurement);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void initialize()
		{
			TD_DbPINVOKE.OdDbDatabase_initialize__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId addOdDbObject(OdDbObject pObject, OdDbObjectId ownerId, OdDbHandle handle)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_addOdDbObject__SWIG_0(this.swigCPtr, OdDbObject.getCPtr(pObject), OdDbObjectId.getCPtr(ownerId), OdDbHandle.getCPtr(handle));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId addOdDbObject(OdDbObject pObject, OdDbObjectId ownerId)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_addOdDbObject__SWIG_1(this.swigCPtr, OdDbObject.getCPtr(pObject), OdDbObjectId.getCPtr(ownerId));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId addOdDbObject(OdDbObject pObject)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_addOdDbObject__SWIG_2(this.swigCPtr, OdDbObject.getCPtr(pObject));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool newRegApp(string regAppName)
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_newRegApp(this.swigCPtr, regAppName);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getBlockTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getBlockTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayerTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayerTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getTextStyleTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getTextStyleTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLinetypeTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLinetypeTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getViewTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getViewTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getUCSTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getUCSTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getViewportTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getViewportTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getRegAppTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getRegAppTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getDimStyleTableId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getDimStyleTableId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getMLStyleDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getMLStyleDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getMLStyleDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getMLStyleDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getGroupDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getGroupDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getGroupDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getGroupDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayoutDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayoutDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayoutDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayoutDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getPlotStyleNameDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPlotStyleNameDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getPlotStyleNameDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPlotStyleNameDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getNamedObjectsDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getNamedObjectsDictionaryId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getPlotSettingsDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPlotSettingsDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getPlotSettingsDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPlotSettingsDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getColorDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getColorDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getColorDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getColorDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getMaterialDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getMaterialDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getMaterialDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getMaterialDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getVisualStyleDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getVisualStyleDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getVisualStyleDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getVisualStyleDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getTableStyleDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getTableStyleDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getTableStyleDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getTableStyleDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getScaleListDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getScaleListDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getScaleListDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getScaleListDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId tablestyle()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_tablestyle(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTablestyle(OdDbObjectId objectId)
		{
			TD_DbPINVOKE.OdDbDatabase_setTablestyle(this.swigCPtr, OdDbObjectId.getCPtr(objectId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getMLeaderStyleDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getMLeaderStyleDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getMLeaderStyleDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getMLeaderStyleDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId mleaderstyle()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_mleaderstyle(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setMLeaderstyle(OdDbObjectId objectId)
		{
			TD_DbPINVOKE.OdDbDatabase_setMLeaderstyle(this.swigCPtr, OdDbObjectId.getCPtr(objectId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getDetailViewStyleDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getDetailViewStyleDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getDetailViewStyleDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getDetailViewStyleDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId detailViewStyle()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_detailViewStyle(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDetailViewStyle(OdDbObjectId objectId)
		{
			TD_DbPINVOKE.OdDbDatabase_setDetailViewStyle(this.swigCPtr, OdDbObjectId.getCPtr(objectId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getSectionViewStyleDictionaryId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getSectionViewStyleDictionaryId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getSectionViewStyleDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getSectionViewStyleDictionaryId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId sectionViewStyle()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_sectionViewStyle(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSectionViewStyle(OdDbObjectId objectId)
		{
			TD_DbPINVOKE.OdDbDatabase_setSectionViewStyle(this.swigCPtr, OdDbObjectId.getCPtr(objectId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getRegAppAcadId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getRegAppAcadId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLinetypeContinuousId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLinetypeContinuousId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLinetypeByLayerId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLinetypeByLayerId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLinetypeByBlockId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLinetypeByBlockId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getModelSpaceId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getModelSpaceId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getPaperSpaceId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPaperSpaceId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getTextStyleStandardId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getTextStyleStandardId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getDimStyleStandardId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getDimStyleStandardId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayerZeroId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayerZeroId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayerDefpointsId(bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayerDefpointsId__SWIG_0(this.swigCPtr, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayerDefpointsId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayerDefpointsId__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayerAdskId(LayerAdskType layerType, bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayerAdskId__SWIG_0(this.swigCPtr, (int)layerType, createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getLayerAdskId(LayerAdskType layerType)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getLayerAdskId__SWIG_1(this.swigCPtr, (int)layerType);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getSectionManager()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getSectionManager(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getPointCloudDictionaryId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPointCloudDictionaryId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string classDxfName(OdRxClass pClass)
		{
			string result = TD_DbPINVOKE.OdDbDatabase_classDxfName(this.swigCPtr, OdRxClass.getCPtr(pClass));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getOdDbObjectId(OdDbHandle objHandle, bool createIfNotFound, uint xRefId)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getOdDbObjectId__SWIG_0(this.swigCPtr, OdDbHandle.getCPtr(objHandle), createIfNotFound, xRefId);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getOdDbObjectId(OdDbHandle objHandle, bool createIfNotFound)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getOdDbObjectId__SWIG_1(this.swigCPtr, OdDbHandle.getCPtr(objHandle), createIfNotFound);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getOdDbObjectId(OdDbHandle objHandle)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getOdDbObjectId__SWIG_2(this.swigCPtr, OdDbHandle.getCPtr(objHandle));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void writeFile(OdStreamBuf pStreamBuf, SaveType fileType, DwgVersion fileVersion, bool saveThumbnailImage, int dxfPrecision)
		{
			TD_DbPINVOKE.OdDbDatabase_writeFile__SWIG_0(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), (int)fileType, (int)fileVersion, saveThumbnailImage, dxfPrecision);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void writeFile(OdStreamBuf pStreamBuf, SaveType fileType, DwgVersion fileVersion, bool saveThumbnailImage)
		{
			TD_DbPINVOKE.OdDbDatabase_writeFile__SWIG_1(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), (int)fileType, (int)fileVersion, saveThumbnailImage);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void writeFile(OdStreamBuf pStreamBuf, SaveType fileType, DwgVersion fileVersion)
		{
			TD_DbPINVOKE.OdDbDatabase_writeFile__SWIG_2(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), (int)fileType, (int)fileVersion);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void writeFile(string filename, SaveType fileType, DwgVersion fileVersion, bool saveThumbnailImage, int dxfPrecision)
		{
			TD_DbPINVOKE.OdDbDatabase_writeFile__SWIG_3(this.swigCPtr, filename, (int)fileType, (int)fileVersion, saveThumbnailImage, dxfPrecision);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void writeFile(string filename, SaveType fileType, DwgVersion fileVersion, bool saveThumbnailImage)
		{
			TD_DbPINVOKE.OdDbDatabase_writeFile__SWIG_4(this.swigCPtr, filename, (int)fileType, (int)fileVersion, saveThumbnailImage);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void writeFile(string filename, SaveType fileType, DwgVersion fileVersion)
		{
			TD_DbPINVOKE.OdDbDatabase_writeFile__SWIG_5(this.swigCPtr, filename, (int)fileType, (int)fileVersion);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(OdStreamBuf pStreamBuf, bool partialLoad, OdDbAuditInfo pAuditInfo, string password, bool allowCPConversion)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_0(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), partialLoad, OdDbAuditInfo.getCPtr(pAuditInfo), password, allowCPConversion);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(OdStreamBuf pStreamBuf, bool partialLoad, OdDbAuditInfo pAuditInfo, string password)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_1(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), partialLoad, OdDbAuditInfo.getCPtr(pAuditInfo), password);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(OdStreamBuf pStreamBuf, bool partialLoad, OdDbAuditInfo pAuditInfo)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_2(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), partialLoad, OdDbAuditInfo.getCPtr(pAuditInfo));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(OdStreamBuf pStreamBuf, bool partialLoad)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_3(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), partialLoad);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(OdStreamBuf pStreamBuf)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_4(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(string filename, bool partialLoad, FileShareMode shareMode, string password, bool allowCPConversion)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_5(this.swigCPtr, filename, partialLoad, (int)shareMode, password, allowCPConversion);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(string filename, bool partialLoad, FileShareMode shareMode, string password)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_6(this.swigCPtr, filename, partialLoad, (int)shareMode, password);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(string filename, bool partialLoad, FileShareMode shareMode)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_7(this.swigCPtr, filename, partialLoad, (int)shareMode);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(string filename, bool partialLoad)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_8(this.swigCPtr, filename, partialLoad);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void readFile(string filename)
		{
			TD_DbPINVOKE.OdDbDatabase_readFile__SWIG_9(this.swigCPtr, filename);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void closeInput()
		{
			TD_DbPINVOKE.OdDbDatabase_closeInput(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int approxNumObjects()
		{
			int result = TD_DbPINVOKE.OdDbDatabase_approxNumObjects(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion version(out MaintReleaseVer pMaintReleaseVer)
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_version__SWIG_0(this.swigCPtr, out pMaintReleaseVer);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion version()
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_version__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public int numberOfSaves()
		{
			int result = TD_DbPINVOKE.OdDbDatabase_numberOfSaves(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion lastSavedAsVersion(out MaintReleaseVer pMaintReleaseVer)
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_lastSavedAsVersion__SWIG_0(this.swigCPtr, out pMaintReleaseVer);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion lastSavedAsVersion()
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_lastSavedAsVersion__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public SaveType originalFileType()
		{
			SaveType result = (SaveType)TD_DbPINVOKE.OdDbDatabase_originalFileType(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion originalFileVersion(out MaintReleaseVer pMaintReleaseVer)
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_originalFileVersion__SWIG_0(this.swigCPtr, out pMaintReleaseVer);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion originalFileVersion()
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_originalFileVersion__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion originalFileSavedByVersion(out MaintReleaseVer pMaintReleaseVer)
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_originalFileSavedByVersion__SWIG_0(this.swigCPtr, out pMaintReleaseVer);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public DwgVersion originalFileSavedByVersion()
		{
			DwgVersion result = (DwgVersion)TD_DbPINVOKE.OdDbDatabase_originalFileSavedByVersion__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void addReactor(OdDbDatabaseReactor pReactor)
		{
			TD_DbPINVOKE.OdDbDatabase_addReactor(this.swigCPtr, OdDbDatabaseReactor.getCPtr(pReactor));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void removeReactor(OdDbDatabaseReactor pReactor)
		{
			TD_DbPINVOKE.OdDbDatabase_removeReactor(this.swigCPtr, OdDbDatabaseReactor.getCPtr(pReactor));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int dimfit()
		{
			int result = TD_DbPINVOKE.OdDbDatabase_dimfit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public int dimunit()
		{
			int result = TD_DbPINVOKE.OdDbDatabase_dimunit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimfit(int val)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimfit(this.swigCPtr, val);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDimunit(int val)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimunit(this.swigCPtr, val);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void deepCloneObjects(OdDbObjectIdArray objectIds, OdDbObjectId ownerId, OdDbIdMapping idMap, bool deferXlation)
		{
			TD_DbPINVOKE.OdDbDatabase_deepCloneObjects__SWIG_0(this.swigCPtr, OdDbObjectIdArray.getCPtr(objectIds), OdDbObjectId.getCPtr(ownerId), OdDbIdMapping.getCPtr(idMap), deferXlation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void deepCloneObjects(OdDbObjectIdArray objectIds, OdDbObjectId ownerId, OdDbIdMapping idMap)
		{
			TD_DbPINVOKE.OdDbDatabase_deepCloneObjects__SWIG_1(this.swigCPtr, OdDbObjectIdArray.getCPtr(objectIds), OdDbObjectId.getCPtr(ownerId), OdDbIdMapping.getCPtr(idMap));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void wblockCloneObjects(OdDbObjectIdArray objectIds, OdDbObjectId ownerId, OdDbIdMapping idMap, DuplicateRecordCloning duplicateRecordCloning, bool deferXlation)
		{
			TD_DbPINVOKE.OdDbDatabase_wblockCloneObjects__SWIG_0(this.swigCPtr, OdDbObjectIdArray.getCPtr(objectIds), OdDbObjectId.getCPtr(ownerId), OdDbIdMapping.getCPtr(idMap), (int)duplicateRecordCloning, deferXlation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void wblockCloneObjects(OdDbObjectIdArray objectIds, OdDbObjectId ownerId, OdDbIdMapping idMap, DuplicateRecordCloning duplicateRecordCloning)
		{
			TD_DbPINVOKE.OdDbDatabase_wblockCloneObjects__SWIG_1(this.swigCPtr, OdDbObjectIdArray.getCPtr(objectIds), OdDbObjectId.getCPtr(ownerId), OdDbIdMapping.getCPtr(idMap), (int)duplicateRecordCloning);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void abortDeepClone(OdDbIdMapping idMap)
		{
			TD_DbPINVOKE.OdDbDatabase_abortDeepClone(this.swigCPtr, OdDbIdMapping.getCPtr(idMap));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void audit(OdDbAuditInfo pAuditInfo)
		{
			TD_DbPINVOKE.OdDbDatabase_audit(this.swigCPtr, OdDbAuditInfo.getCPtr(pAuditInfo));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void startTransaction()
		{
			TD_DbPINVOKE.OdDbDatabase_startTransaction(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void endTransaction()
		{
			TD_DbPINVOKE.OdDbDatabase_endTransaction(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void abortTransaction()
		{
			TD_DbPINVOKE.OdDbDatabase_abortTransaction(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual int numActiveTransactions()
		{
			int result = TD_DbPINVOKE.OdDbDatabase_numActiveTransactions(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void addTransactionReactor(OdDbTransactionReactor reactor)
		{
			TD_DbPINVOKE.OdDbDatabase_addTransactionReactor(this.swigCPtr, OdDbTransactionReactor.getCPtr(reactor));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void removeTransactionReactor(OdDbTransactionReactor reactor)
		{
			TD_DbPINVOKE.OdDbDatabase_removeTransactionReactor(this.swigCPtr, OdDbTransactionReactor.getCPtr(reactor));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public IntPtr thumbnailBitmap(out uint dataLength)
		{
			IntPtr result = TD_DbPINVOKE.OdDbDatabase_thumbnailBitmap(this.swigCPtr, out dataLength);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setThumbnailBitmap(IntPtr pBMPData, uint dataLength)
		{
			TD_DbPINVOKE.OdDbDatabase_setThumbnailBitmap(this.swigCPtr, pBMPData, dataLength);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool retainOriginalThumbnailBitmap()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_retainOriginalThumbnailBitmap(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setRetainOriginalThumbnailBitmap(bool retain)
		{
			TD_DbPINVOKE.OdDbDatabase_setRetainOriginalThumbnailBitmap(this.swigCPtr, retain);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void dwgOutFields(OdDbDwgFiler pFiler)
		{
			TD_DbPINVOKE.OdDbDatabase_dwgOutFields(this.swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult dwgInFields(OdDbDwgFiler pFiler)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDatabase_dwgInFields(this.swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool getDIMANNO()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getDIMANNO(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbDate getTDCREATE()
		{
			OdDbDate result = new OdDbDate(TD_DbPINVOKE.OdDbDatabase_getTDCREATE(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbDate getTDUPDATE()
		{
			OdDbDate result = new OdDbDate(TD_DbPINVOKE.OdDbDatabase_getTDUPDATE(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void resetTimes()
		{
			TD_DbPINVOKE.OdDbDatabase_resetTimes(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdResBuf getSysVar(string name)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_getSysVar(this.swigCPtr, name);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSysVar(string name, OdResBuf pValue)
		{
			TD_DbPINVOKE.OdDbDatabase_setSysVar(this.swigCPtr, name, OdResBuf.getCPtr(pValue));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbHandle handseed()
		{
			OdDbHandle result = new OdDbHandle(TD_DbPINVOKE.OdDbDatabase_handseed(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void getDimstyleData(OdDbDimStyleTableRecord pDestination)
		{
			TD_DbPINVOKE.OdDbDatabase_getDimstyleData(this.swigCPtr, OdDbDimStyleTableRecord.getCPtr(pDestination));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDimstyleData(OdDbDimStyleTableRecord pSource)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimstyleData__SWIG_0(this.swigCPtr, OdDbDimStyleTableRecord.getCPtr(pSource));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDimstyleData(OdDbObjectId objectId)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimstyleData__SWIG_1(this.swigCPtr, OdDbObjectId.getCPtr(objectId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void loadLineTypeFile(string ltName, string filename, DuplicateLinetypeLoading dlt, TextFileEncoding encode)
		{
			TD_DbPINVOKE.OdDbDatabase_loadLineTypeFile__SWIG_0(this.swigCPtr, ltName, filename, (int)dlt, (int)encode);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void loadLineTypeFile(string ltName, string filename, DuplicateLinetypeLoading dlt)
		{
			TD_DbPINVOKE.OdDbDatabase_loadLineTypeFile__SWIG_1(this.swigCPtr, ltName, filename, (int)dlt);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void loadLineTypeFile(string ltName, string filename)
		{
			TD_DbPINVOKE.OdDbDatabase_loadLineTypeFile__SWIG_2(this.swigCPtr, ltName, filename);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string getFilename()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_getFilename(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void purge(OdDbObjectIdArray objectIds)
		{
			TD_DbPINVOKE.OdDbDatabase_purge__SWIG_0(this.swigCPtr, OdDbObjectIdArray.getCPtr(objectIds));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdResult purge(SWIGTYPE_p_OdDbObjectIdGraph objectIds)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDatabase_purge__SWIG_1(this.swigCPtr, SWIGTYPE_p_OdDbObjectIdGraph.getCPtr(objectIds));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void countHardReferences(OdDbObjectIdArray objectIds, OdUInt32Array counts)
		{
			TD_DbPINVOKE.OdDbDatabase_countHardReferences(this.swigCPtr, OdDbObjectIdArray.getCPtr(objectIds), OdUInt32Array.getCPtr(counts).Handle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId currentLayoutId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_currentLayoutId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCurrentLayout(string layoutName)
		{
			TD_DbPINVOKE.OdDbDatabase_setCurrentLayout__SWIG_0(this.swigCPtr, layoutName);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setCurrentLayout(OdDbObjectId layoutId)
		{
			TD_DbPINVOKE.OdDbDatabase_setCurrentLayout__SWIG_1(this.swigCPtr, OdDbObjectId.getCPtr(layoutId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string findActiveLayout(bool allowModel)
		{
			string result = TD_DbPINVOKE.OdDbDatabase_findActiveLayout(this.swigCPtr, allowModel);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbObjectId getActiveLayoutBTRId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getActiveLayoutBTRId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbObjectId findLayoutNamed(string layoutName)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_findLayoutNamed(this.swigCPtr, layoutName);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void deleteLayout(string layoutName)
		{
			TD_DbPINVOKE.OdDbDatabase_deleteLayout(this.swigCPtr, layoutName);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId createLayout(string layoutName, OdDbObjectId pBlockTableRecId)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_createLayout__SWIG_0(this.swigCPtr, layoutName, OdDbObjectId.getCPtr(pBlockTableRecId));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbObjectId createLayout(string layoutName)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_createLayout__SWIG_1(this.swigCPtr, layoutName);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int countLayouts()
		{
			int result = TD_DbPINVOKE.OdDbDatabase_countLayouts(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void renameLayout(string oldName, string newName)
		{
			TD_DbPINVOKE.OdDbDatabase_renameLayout(this.swigCPtr, oldName, newName);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void startUndoRecord()
		{
			TD_DbPINVOKE.OdDbDatabase_startUndoRecord(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool hasUndo()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_hasUndo(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void undo()
		{
			TD_DbPINVOKE.OdDbDatabase_undo(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void blockUndoRecording(bool bBegin)
		{
			TD_DbPINVOKE.OdDbDatabase_blockUndoRecording(this.swigCPtr, bBegin);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isUndoBlockStarted()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_isUndoBlockStarted(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setUndoMark()
		{
			TD_DbPINVOKE.OdDbDatabase_setUndoMark(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool hasUndoMark()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_hasUndoMark(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void undoBack()
		{
			TD_DbPINVOKE.OdDbDatabase_undoBack(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int getUNDOMARKS()
		{
			int result = TD_DbPINVOKE.OdDbDatabase_getUNDOMARKS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void clearUndo()
		{
			TD_DbPINVOKE.OdDbDatabase_clearUndo(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool hasRedo()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_hasRedo(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void redo()
		{
			TD_DbPINVOKE.OdDbDatabase_redo(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void auditDatabase(OdDbAuditInfo pAuditInfo)
		{
			TD_DbPINVOKE.OdDbDatabase_auditDatabase(this.swigCPtr, OdDbAuditInfo.getCPtr(pAuditInfo));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void applyPartialUndo(OdDbDwgFiler pUndoFiler, OdRxClass pClassObj)
		{
			TD_DbPINVOKE.OdDbDatabase_applyPartialUndo(this.swigCPtr, OdDbDwgFiler.getCPtr(pUndoFiler), OdRxClass.getCPtr(pClassObj));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new OdDbDwgFiler undoFiler()
		{
			OdDbDwgFiler result = (OdDbDwgFiler)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDatabase_undoFiler(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId insert(string destinationBlockName, OdDbDatabase pSource, bool preserveSourceDatabase)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_insert__SWIG_0(this.swigCPtr, destinationBlockName, OdDbDatabase.getCPtr(pSource), preserveSourceDatabase);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId insert(string destinationBlockName, OdDbDatabase pSource)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_insert__SWIG_1(this.swigCPtr, destinationBlockName, OdDbDatabase.getCPtr(pSource));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId insert(string sourceBlockName, string destinationBlockName, OdDbDatabase pSource, bool preserveSourceDatabase)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_insert__SWIG_2(this.swigCPtr, sourceBlockName, destinationBlockName, OdDbDatabase.getCPtr(pSource), preserveSourceDatabase);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId insert(string sourceBlockName, string destinationBlockName, OdDbDatabase pSource)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_insert__SWIG_3(this.swigCPtr, sourceBlockName, destinationBlockName, OdDbDatabase.getCPtr(pSource));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void insert(OdGeMatrix3d xfm, OdDbDatabase pSource, bool preserveSourceDatabase)
		{
			TD_DbPINVOKE.OdDbDatabase_insert__SWIG_4(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm), OdDbDatabase.getCPtr(pSource), preserveSourceDatabase);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void insert(OdGeMatrix3d xfm, OdDbDatabase pSource)
		{
			TD_DbPINVOKE.OdDbDatabase_insert__SWIG_5(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm), OdDbDatabase.getCPtr(pSource));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbDatabase wblock(OdDbObjectIdArray outObjIds, OdGePoint3d basePoint)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_wblock__SWIG_0(this.swigCPtr, OdDbObjectIdArray.getCPtr(outObjIds), OdGePoint3d.getCPtr(basePoint));
			OdDbDatabase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbDatabase wblock(OdDbObjectId blockId)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_wblock__SWIG_1(this.swigCPtr, OdDbObjectId.getCPtr(blockId));
			OdDbDatabase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbDatabase wblock()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_wblock__SWIG_2(this.swigCPtr);
			OdDbDatabase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDatabase)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbObject subWblockClone(OdDbIdMapping ownerIdMap, OdDbObject arg1)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_subWblockClone(this.swigCPtr, OdDbIdMapping.getCPtr(ownerIdMap), OdDbObject.getCPtr(arg1));
			OdDbObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSecurityParams(OdSecurityParams secParams, bool setDbMod)
		{
			TD_DbPINVOKE.OdDbDatabase_setSecurityParams__SWIG_0(this.swigCPtr, OdSecurityParams.getCPtr(secParams), setDbMod);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setSecurityParams(OdSecurityParams secParams)
		{
			TD_DbPINVOKE.OdDbDatabase_setSecurityParams__SWIG_1(this.swigCPtr, OdSecurityParams.getCPtr(secParams));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool securityParams(OdSecurityParams secParams)
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_securityParams(this.swigCPtr, OdSecurityParams.getCPtr(secParams));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdFileDependencyManager fileDependencyManager()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_fileDependencyManager(this.swigCPtr);
			OdFileDependencyManager result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdFileDependencyManager)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdFileDependencyManager)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdFileDependencyManager)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectContextManager objectContextManager()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_objectContextManager(this.swigCPtr);
			OdDbObjectContextManager result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbObjectContextManager)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbObjectContextManager)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbObjectContextManager)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbLayerStateManager getLayerStateManager()
		{
			OdDbLayerStateManager result = (OdDbLayerStateManager)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDatabase_getLayerStateManager(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void updateExt(bool bExact)
		{
			TD_DbPINVOKE.OdDbDatabase_updateExt__SWIG_0(this.swigCPtr, bExact);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void updateExt()
		{
			TD_DbPINVOKE.OdDbDatabase_updateExt__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isEMR()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_isEMR(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId xrefBlockId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_xrefBlockId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isPartiallyOpened()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_isPartiallyOpened(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isDatabaseLoading()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_isDatabaseLoading(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isDatabaseConverting()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_isDatabaseConverting(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbAuditInfo auditInfo()
		{
			IntPtr intPtr = TD_DbPINVOKE.OdDbDatabase_auditInfo(this.swigCPtr);
			OdDbAuditInfo result = (intPtr == IntPtr.Zero) ? null : new OdDbAuditInfo(intPtr, false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setCurrentUCS(OrthographicView viewType)
		{
			TD_DbPINVOKE.OdDbDatabase_setCurrentUCS__SWIG_0(this.swigCPtr, (int)viewType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setCurrentUCS(OdDbObjectId ucsId)
		{
			TD_DbPINVOKE.OdDbDatabase_setCurrentUCS__SWIG_1(this.swigCPtr, OdDbObjectId.getCPtr(ucsId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setCurrentUCS(OdGePoint3d origin, OdGeVector3d xAxis, OdGeVector3d yAxis)
		{
			TD_DbPINVOKE.OdDbDatabase_setCurrentUCS__SWIG_2(this.swigCPtr, OdGePoint3d.getCPtr(origin), OdGeVector3d.getCPtr(xAxis), OdGeVector3d.getCPtr(yAxis));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGePoint3d getUCSBASEORG(OrthographicView viewType)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSBASEORG(this.swigCPtr, (int)viewType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setUCSBASEORG(OrthographicView viewType, OdGePoint3d origin)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSBASEORG(this.swigCPtr, (int)viewType, OdGePoint3d.getCPtr(origin));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGePoint3d getPUCSBASEORG(OrthographicView viewType)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSBASEORG(this.swigCPtr, (int)viewType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setPUCSBASEORG(OrthographicView viewType, OdGePoint3d origin)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSBASEORG(this.swigCPtr, (int)viewType, OdGePoint3d.getCPtr(origin));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void restoreOriginalXrefSymbols()
		{
			TD_DbPINVOKE.OdDbDatabase_restoreOriginalXrefSymbols(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void restoreForwardingXrefSymbols()
		{
			TD_DbPINVOKE.OdDbDatabase_restoreForwardingXrefSymbols(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static bool isValidLineWeight(int weight)
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_isValidLineWeight(weight);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static LineWeight getNearestLineWeight(int weight)
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbDatabase_getNearestLineWeight(weight);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId byLayerMaterialId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_byLayerMaterialId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId byBlockMaterialId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_byBlockMaterialId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId globalMaterialId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_globalMaterialId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId activeViewportId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_activeViewportId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbUnitsFormatter formatter()
		{
			OdDbUnitsFormatter result = (OdDbUnitsFormatter)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDatabase_formatter(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void enableGraphicsFlush(bool bEnable)
		{
			TD_DbPINVOKE.OdDbDatabase_enableGraphicsFlush(this.swigCPtr, bEnable);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void flushGraphics()
		{
			TD_DbPINVOKE.OdDbDatabase_flushGraphics(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isMultiThreadedMode()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_isMultiThreadedMode(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public MultiThreadedMode multiThreadedMode()
		{
			MultiThreadedMode result = (MultiThreadedMode)TD_DbPINVOKE.OdDbDatabase_multiThreadedMode(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMultiThreadedMode(MultiThreadedMode arg0)
		{
			TD_DbPINVOKE.OdDbDatabase_setMultiThreadedMode(this.swigCPtr, (int)arg0);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setCannoscale(OdDbAnnotationScale val)
		{
			TD_DbPINVOKE.OdDbDatabase_setCannoscale(this.swigCPtr, OdDbAnnotationScale.getCPtr(val));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbAnnotationScale cannoscale()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_cannoscale(this.swigCPtr);
			OdDbAnnotationScale result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbAnnotationScale)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbAnnotationScale)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbAnnotationScale)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setANGBASE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setANGBASE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getANGBASE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getANGBASE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setANGDIR(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setANGDIR(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getANGDIR()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getANGDIR(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINSBASE(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINSBASE(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getINSBASE()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getINSBASE(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setEXTMIN(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setEXTMIN(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getEXTMIN()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getEXTMIN(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setEXTMAX(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setEXTMAX(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getEXTMAX()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getEXTMAX(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLIMMIN(OdGePoint2d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLIMMIN(this.swigCPtr, OdGePoint2d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint2d getLIMMIN()
		{
			OdGePoint2d result = new OdGePoint2d(TD_DbPINVOKE.OdDbDatabase_getLIMMIN(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLIMMAX(OdGePoint2d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLIMMAX(this.swigCPtr, OdGePoint2d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint2d getLIMMAX()
		{
			OdGePoint2d result = new OdGePoint2d(TD_DbPINVOKE.OdDbDatabase_getLIMMAX(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setORTHOMODE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setORTHOMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getORTHOMODE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getORTHOMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setREGENMODE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setREGENMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getREGENMODE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getREGENMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFILLMODE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setFILLMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getFILLMODE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getFILLMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setQTEXTMODE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setQTEXTMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getQTEXTMODE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getQTEXTMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMIRRTEXT(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setMIRRTEXT(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getMIRRTEXT()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getMIRRTEXT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLTSCALE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLTSCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLTSCALE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLTSCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setATTMODE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setATTMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getATTMODE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getATTMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTEXTSIZE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTEXTSIZE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getTEXTSIZE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getTEXTSIZE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTRACEWID(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTRACEWID(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getTRACEWID()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getTRACEWID(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTEXTSTYLE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTEXTSTYLE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getTEXTSTYLE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getTEXTSTYLE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCLAYER(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCLAYER(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCLAYER()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCLAYER(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCELTYPE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCELTYPE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCELTYPE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCELTYPE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCECOLOR(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCECOLOR(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor getCECOLOR()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDatabase_getCECOLOR(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCELTSCALE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCELTSCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getCELTSCALE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getCELTSCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCHAMFERA(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCHAMFERA(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getCHAMFERA()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getCHAMFERA(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCHAMFERB(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCHAMFERB(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getCHAMFERB()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getCHAMFERB(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCHAMFERC(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCHAMFERC(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getCHAMFERC()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getCHAMFERC(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCHAMFERD(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCHAMFERD(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getCHAMFERD()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getCHAMFERD(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDISPSILH(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDISPSILH(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getDISPSILH()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getDISPSILH(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDIMSTYLE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDIMSTYLE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getDIMSTYLE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getDIMSTYLE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDIMASO(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDIMASO(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getDIMASO()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getDIMASO(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDIMSHO(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDIMSHO(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getDIMSHO()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getDIMSHO(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLUNITS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLUNITS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getLUNITS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getLUNITS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLUPREC(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLUPREC(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getLUPREC()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getLUPREC(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSKETCHINC(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSKETCHINC(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getSKETCHINC()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getSKETCHINC(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFILLETRAD(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setFILLETRAD(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getFILLETRAD()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getFILLETRAD(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setAUNITS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setAUNITS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getAUNITS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getAUNITS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setAUPREC(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setAUPREC(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getAUPREC()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getAUPREC(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMENUNAME(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setMENUNAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string getMENUNAME()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_getMENUNAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setELEVATION(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setELEVATION(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getELEVATION()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getELEVATION(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPELEVATION(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPELEVATION(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getPELEVATION()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getPELEVATION(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTHICKNESS(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTHICKNESS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getTHICKNESS()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getTHICKNESS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLIMCHECK(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLIMCHECK(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getLIMCHECK()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getLIMCHECK(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSKPOLY(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSKPOLY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getSKPOLY()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getSKPOLY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbDate getTDUCREATE()
		{
			OdDbDate result = new OdDbDate(TD_DbPINVOKE.OdDbDatabase_getTDUCREATE(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbDate getTDUUPDATE()
		{
			OdDbDate result = new OdDbDate(TD_DbPINVOKE.OdDbDatabase_getTDUUPDATE(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbDate getTDINDWG()
		{
			OdDbDate result = new OdDbDate(TD_DbPINVOKE.OdDbDatabase_getTDINDWG(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbDate getTDUSRTIMER()
		{
			OdDbDate result = new OdDbDate(TD_DbPINVOKE.OdDbDatabase_getTDUSRTIMER(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSRTIMER(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSRTIMER(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getUSRTIMER()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getUSRTIMER(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPDMODE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPDMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getPDMODE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getPDMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPDSIZE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPDSIZE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getPDSIZE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getPDSIZE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPLINEWID(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPLINEWID(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getPLINEWID()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getPLINEWID(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSPLFRAME(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSPLFRAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getSPLFRAME()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getSPLFRAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSPLINETYPE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSPLINETYPE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSPLINETYPE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSPLINETYPE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSPLINESEGS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSPLINESEGS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSPLINESEGS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSPLINESEGS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSURFTAB1(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSURFTAB1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSURFTAB1()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSURFTAB1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSURFTAB2(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSURFTAB2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSURFTAB2()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSURFTAB2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSURFTYPE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSURFTYPE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSURFTYPE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSURFTYPE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSURFU(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSURFU(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSURFU()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSURFU(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSURFV(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSURFV(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSURFV()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSURFV(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERI1(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERI1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUSERI1()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUSERI1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERI2(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERI2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUSERI2()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUSERI2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERI3(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERI3(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUSERI3()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUSERI3(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERI4(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERI4(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUSERI4()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUSERI4(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERI5(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERI5(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUSERI5()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUSERI5(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERR1(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERR1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getUSERR1()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getUSERR1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERR2(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERR2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getUSERR2()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getUSERR2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERR3(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERR3(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getUSERR3()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getUSERR3(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERR4(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERR4(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getUSERR4()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getUSERR4(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUSERR5(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUSERR5(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getUSERR5()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getUSERR5(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setWORLDVIEW(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setWORLDVIEW(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getWORLDVIEW()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getWORLDVIEW(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSHADEDGE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSHADEDGE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSHADEDGE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSHADEDGE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSHADEDIF(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSHADEDIF(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSHADEDIF()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSHADEDIF(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTILEMODE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTILEMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getTILEMODE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getTILEMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMAXACTVP(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setMAXACTVP(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getMAXACTVP()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getMAXACTVP(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPINSBASE(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPINSBASE(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPINSBASE()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPINSBASE(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPLIMCHECK(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPLIMCHECK(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getPLIMCHECK()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getPLIMCHECK(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPEXTMIN(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPEXTMIN(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPEXTMIN()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPEXTMIN(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPEXTMAX(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPEXTMAX(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPEXTMAX()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPEXTMAX(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPLIMMIN(OdGePoint2d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPLIMMIN(this.swigCPtr, OdGePoint2d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint2d getPLIMMIN()
		{
			OdGePoint2d result = new OdGePoint2d(TD_DbPINVOKE.OdDbDatabase_getPLIMMIN(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPLIMMAX(OdGePoint2d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPLIMMAX(this.swigCPtr, OdGePoint2d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint2d getPLIMMAX()
		{
			OdGePoint2d result = new OdGePoint2d(TD_DbPINVOKE.OdDbDatabase_getPLIMMAX(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSNAME(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSNAME(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getUCSNAME()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getUCSNAME(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSNAME(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSNAME(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getPUCSNAME()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPUCSNAME(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUNITMODE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUNITMODE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUNITMODE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUNITMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setVISRETAIN(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setVISRETAIN(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getVISRETAIN()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getVISRETAIN(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPLINEGEN(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPLINEGEN(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getPLINEGEN()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getPLINEGEN(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPSLTSCALE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPSLTSCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getPSLTSCALE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getPSLTSCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTREEDEPTH(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTREEDEPTH(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getTREEDEPTH()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getTREEDEPTH(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCMLSTYLE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCMLSTYLE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCMLSTYLE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCMLSTYLE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCMLJUST(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCMLJUST(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getCMLJUST()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getCMLJUST(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCMLSCALE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCMLSCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getCMLSCALE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getCMLSCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPROXYGRAPHICS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPROXYGRAPHICS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getPROXYGRAPHICS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getPROXYGRAPHICS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMEASUREMENT(MeasurementValue var)
		{
			TD_DbPINVOKE.OdDbDatabase_setMEASUREMENT(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual MeasurementValue getMEASUREMENT()
		{
			MeasurementValue result = (MeasurementValue)TD_DbPINVOKE.OdDbDatabase_getMEASUREMENT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCELWEIGHT(LineWeight var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCELWEIGHT(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LineWeight getCELWEIGHT()
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbDatabase_getCELWEIGHT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setENDCAPS(EndCaps var)
		{
			TD_DbPINVOKE.OdDbDatabase_setENDCAPS(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual EndCaps getENDCAPS()
		{
			EndCaps result = (EndCaps)TD_DbPINVOKE.OdDbDatabase_getENDCAPS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setJOINSTYLE(JoinStyle var)
		{
			TD_DbPINVOKE.OdDbDatabase_setJOINSTYLE(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual JoinStyle getJOINSTYLE()
		{
			JoinStyle result = (JoinStyle)TD_DbPINVOKE.OdDbDatabase_getJOINSTYLE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLWDISPLAY(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLWDISPLAY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getLWDISPLAY()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getLWDISPLAY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINSUNITS(UnitsValue var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINSUNITS(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual UnitsValue getINSUNITS()
		{
			UnitsValue result = (UnitsValue)TD_DbPINVOKE.OdDbDatabase_getINSUNITS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTSTACKALIGN(ushort var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTSTACKALIGN(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort getTSTACKALIGN()
		{
			ushort result = TD_DbPINVOKE.OdDbDatabase_getTSTACKALIGN(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTSTACKSIZE(ushort var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTSTACKSIZE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort getTSTACKSIZE()
		{
			ushort result = TD_DbPINVOKE.OdDbDatabase_getTSTACKSIZE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setHYPERLINKBASE(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setHYPERLINKBASE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string getHYPERLINKBASE()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_getHYPERLINKBASE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSTYLESHEET(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSTYLESHEET(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string getSTYLESHEET()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_getSTYLESHEET(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setXEDIT(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setXEDIT(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getXEDIT()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getXEDIT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCEPSNTYPE(PlotStyleNameType var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCEPSNTYPE(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual PlotStyleNameType getCEPSNTYPE()
		{
			PlotStyleNameType result = (PlotStyleNameType)TD_DbPINVOKE.OdDbDatabase_getCEPSNTYPE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCEPSNID(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCEPSNID(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCEPSNID()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCEPSNID(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool getPSTYLEMODE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getPSTYLEMODE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFINGERPRINTGUID(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setFINGERPRINTGUID(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string getFINGERPRINTGUID()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_getFINGERPRINTGUID(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setVERSIONGUID(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setVERSIONGUID(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string getVERSIONGUID()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_getVERSIONGUID(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setEXTNAMES(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setEXTNAMES(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getEXTNAMES()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getEXTNAMES(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPSVPSCALE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPSVPSCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getPSVPSCALE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getPSVPSCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setOLESTARTUP(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setOLESTARTUP(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getOLESTARTUP()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getOLESTARTUP(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPELLIPSE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPELLIPSE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getPELLIPSE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getPELLIPSE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setISOLINES(ushort var)
		{
			TD_DbPINVOKE.OdDbDatabase_setISOLINES(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort getISOLINES()
		{
			ushort result = TD_DbPINVOKE.OdDbDatabase_getISOLINES(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTEXTQLTY(ushort var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTEXTQLTY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort getTEXTQLTY()
		{
			ushort result = TD_DbPINVOKE.OdDbDatabase_getTEXTQLTY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFACETRES(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setFACETRES(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getFACETRES()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getFACETRES(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getUCSORG()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSORG(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGeVector3d getUCSXDIR()
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdDbDatabase_getUCSXDIR(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGeVector3d getUCSYDIR()
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdDbDatabase_getUCSYDIR(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSBASE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSBASE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getPUCSBASE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getPUCSBASE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getPUCSORG()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSORG(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGeVector3d getPUCSXDIR()
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdDbDatabase_getPUCSXDIR(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGeVector3d getPUCSYDIR()
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdDbDatabase_getPUCSYDIR(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSORTHOVIEW(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSORTHOVIEW(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getPUCSORTHOVIEW()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getPUCSORTHOVIEW(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSORGTOP(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSORGTOP(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPUCSORGTOP()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSORGTOP(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSORGBOTTOM(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSORGBOTTOM(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPUCSORGBOTTOM()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSORGBOTTOM(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSORGLEFT(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSORGLEFT(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPUCSORGLEFT()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSORGLEFT(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSORGRIGHT(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSORGRIGHT(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPUCSORGRIGHT()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSORGRIGHT(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSORGFRONT(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSORGFRONT(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPUCSORGFRONT()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSORGFRONT(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPUCSORGBACK(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPUCSORGBACK(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getPUCSORGBACK()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getPUCSORGBACK(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSBASE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSBASE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getUCSBASE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getUCSBASE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSORTHOVIEW(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSORTHOVIEW(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUCSORTHOVIEW()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUCSORTHOVIEW(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSORGTOP(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSORGTOP(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getUCSORGTOP()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSORGTOP(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSORGBOTTOM(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSORGBOTTOM(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getUCSORGBOTTOM()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSORGBOTTOM(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSORGLEFT(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSORGLEFT(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getUCSORGLEFT()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSORGLEFT(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSORGRIGHT(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSORGRIGHT(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getUCSORGRIGHT()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSORGRIGHT(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSORGFRONT(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSORGFRONT(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getUCSORGFRONT()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSORGFRONT(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUCSORGBACK(OdGePoint3d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUCSORGBACK(this.swigCPtr, OdGePoint3d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d getUCSORGBACK()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDatabase_getUCSORGBACK(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCodePageId getDWGCODEPAGE()
		{
			OdCodePageId result = (OdCodePageId)TD_DbPINVOKE.OdDbDatabase_getDWGCODEPAGE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCTABLESTYLE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCTABLESTYLE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCTABLESTYLE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCTABLESTYLE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCMLEADERSTYLE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCMLEADERSTYLE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCMLEADERSTYLE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCMLEADERSTYLE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCANNOSCALE(OdDbAnnotationScale var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCANNOSCALE(this.swigCPtr, OdDbAnnotationScale.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbAnnotationScale getCANNOSCALE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDatabase_getCANNOSCALE(this.swigCPtr);
			OdDbAnnotationScale result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbAnnotationScale)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbAnnotationScale)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbAnnotationScale)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setANNOALLVISIBLE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setANNOALLVISIBLE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getANNOALLVISIBLE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getANNOALLVISIBLE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setANNOTATIVEDWG(sbyte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setANNOTATIVEDWG(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual sbyte getANNOTATIVEDWG()
		{
			sbyte result = TD_DbPINVOKE.OdDbDatabase_getANNOTATIVEDWG(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMSLTSCALE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setMSLTSCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getMSLTSCALE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getMSLTSCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLAYEREVAL(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLAYEREVAL(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getLAYEREVAL()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getLAYEREVAL(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLAYERNOTIFY(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLAYERNOTIFY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getLAYERNOTIFY()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getLAYERNOTIFY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLIGHTINGUNITS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLIGHTINGUNITS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getLIGHTINGUNITS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getLIGHTINGUNITS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLIGHTSINBLOCKS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLIGHTSINBLOCKS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getLIGHTSINBLOCKS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getLIGHTSINBLOCKS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDBCSTATE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDBCSTATE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getDBCSTATE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getDBCSTATE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINTERSECTIONCOLOR(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINTERSECTIONCOLOR(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getINTERSECTIONCOLOR()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getINTERSECTIONCOLOR(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINTERSECTIONDISPLAY(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINTERSECTIONDISPLAY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getINTERSECTIONDISPLAY()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getINTERSECTIONDISPLAY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setHALOGAP(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setHALOGAP(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getHALOGAP()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getHALOGAP(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setOBSCUREDCOLOR(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setOBSCUREDCOLOR(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getOBSCUREDCOLOR()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getOBSCUREDCOLOR(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setOBSCUREDLTYPE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setOBSCUREDLTYPE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getOBSCUREDLTYPE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getOBSCUREDLTYPE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINDEXCTL(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINDEXCTL(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getINDEXCTL()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getINDEXCTL(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPROJECTNAME(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPROJECTNAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string getPROJECTNAME()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_getPROJECTNAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSORTENTS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSORTENTS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSORTENTS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSORTENTS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDIMASSOC(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDIMASSOC(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getDIMASSOC()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getDIMASSOC(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setHIDETEXT(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setHIDETEXT(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getHIDETEXT()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getHIDETEXT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDRAWORDERCTL(sbyte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDRAWORDERCTL(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual sbyte getDRAWORDERCTL()
		{
			sbyte result = TD_DbPINVOKE.OdDbDatabase_getDRAWORDERCTL(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setHPINHERIT(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setHPINHERIT(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getHPINHERIT()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getHPINHERIT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setHPORIGIN(OdGePoint2d var)
		{
			TD_DbPINVOKE.OdDbDatabase_setHPORIGIN(this.swigCPtr, OdGePoint2d.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint2d getHPORIGIN()
		{
			OdGePoint2d result = new OdGePoint2d(TD_DbPINVOKE.OdDbDatabase_getHPORIGIN(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFIELDEVAL(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setFIELDEVAL(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getFIELDEVAL()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getFIELDEVAL(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMSOLESCALE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setMSOLESCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getMSOLESCALE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getMSOLESCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setUPDATETHUMBNAIL(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setUPDATETHUMBNAIL(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getUPDATETHUMBNAIL()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getUPDATETHUMBNAIL(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSOLIDHIST(sbyte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSOLIDHIST(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual sbyte getSOLIDHIST()
		{
			sbyte result = TD_DbPINVOKE.OdDbDatabase_getSOLIDHIST(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSHOWHIST(sbyte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSHOWHIST(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual sbyte getSHOWHIST()
		{
			sbyte result = TD_DbPINVOKE.OdDbDatabase_getSHOWHIST(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPSOLWIDTH(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPSOLWIDTH(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getPSOLWIDTH()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getPSOLWIDTH(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLOFTPARAM(LoftParamType var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLOFTPARAM(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LoftParamType getLOFTPARAM()
		{
			LoftParamType result = (LoftParamType)TD_DbPINVOKE.OdDbDatabase_getLOFTPARAM(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLOFTNORMALS(LoftNormalsType var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLOFTNORMALS(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LoftNormalsType getLOFTNORMALS()
		{
			LoftNormalsType result = (LoftNormalsType)TD_DbPINVOKE.OdDbDatabase_getLOFTNORMALS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLOFTANG1(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLOFTANG1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLOFTANG1()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLOFTANG1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLOFTANG2(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLOFTANG2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLOFTANG2()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLOFTANG2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLOFTMAG1(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLOFTMAG1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLOFTMAG1()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLOFTMAG1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLOFTMAG2(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLOFTMAG2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLOFTMAG2()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLOFTMAG2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLATITUDE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLATITUDE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLATITUDE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLATITUDE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLONGITUDE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLONGITUDE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLONGITUDE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLONGITUDE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setNORTHDIRECTION(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setNORTHDIRECTION(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getNORTHDIRECTION()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getNORTHDIRECTION(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTIMEZONE(TimeZone var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTIMEZONE(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual TimeZone getTIMEZONE()
		{
			TimeZone result = (TimeZone)TD_DbPINVOKE.OdDbDatabase_getTIMEZONE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLIGHTGLYPHDISPLAY(sbyte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLIGHTGLYPHDISPLAY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual sbyte getLIGHTGLYPHDISPLAY()
		{
			sbyte result = TD_DbPINVOKE.OdDbDatabase_getLIGHTGLYPHDISPLAY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTILEMODELIGHTSYNCH(sbyte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setTILEMODELIGHTSYNCH(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual sbyte getTILEMODELIGHTSYNCH()
		{
			sbyte result = TD_DbPINVOKE.OdDbDatabase_getTILEMODELIGHTSYNCH(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINTERFERECOLOR(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINTERFERECOLOR(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor getINTERFERECOLOR()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDatabase_getINTERFERECOLOR(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINTERFEREOBJVS(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINTERFEREOBJVS(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getINTERFEREOBJVS()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getINTERFEREOBJVS(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setINTERFEREVPVS(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setINTERFEREVPVS(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getINTERFEREVPVS()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getINTERFEREVPVS(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDRAGVS(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDRAGVS(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getDRAGVS()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getDRAGVS(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCSHADOW(OdGiSubEntityTraits.ShadowFlags var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCSHADOW(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGiSubEntityTraits.ShadowFlags getCSHADOW()
		{
			OdGiSubEntityTraits.ShadowFlags result = (OdGiSubEntityTraits.ShadowFlags)TD_DbPINVOKE.OdDbDatabase_getCSHADOW(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSHADOWPLANELOCATION(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSHADOWPLANELOCATION(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getSHADOWPLANELOCATION()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getSHADOWPLANELOCATION(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCAMERADISPLAY(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCAMERADISPLAY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getCAMERADISPLAY()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getCAMERADISPLAY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLENSLENGTH(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setLENSLENGTH(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getLENSLENGTH()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getLENSLENGTH(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCAMERAHEIGHT(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCAMERAHEIGHT(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getCAMERAHEIGHT()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getCAMERAHEIGHT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSTEPSPERSEC(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSTEPSPERSEC(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getSTEPSPERSEC()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getSTEPSPERSEC(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSTEPSIZE(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSTEPSIZE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getSTEPSIZE()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getSTEPSIZE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void set3DDWFPREC(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_set3DDWFPREC(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double get3DDWFPREC()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_get3DDWFPREC(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPSOLHEIGHT(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPSOLHEIGHT(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double getPSOLHEIGHT()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_getPSOLHEIGHT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCMATERIAL(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCMATERIAL(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCMATERIAL()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCMATERIAL(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDGNFRAME(sbyte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDGNFRAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual sbyte getDGNFRAME()
		{
			sbyte result = TD_DbPINVOKE.OdDbDatabase_getDGNFRAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setREALWORLDSCALE(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setREALWORLDSCALE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool getREALWORLDSCALE()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_getREALWORLDSCALE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDXEVAL(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDXEVAL(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getDXEVAL()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getDXEVAL(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setGEOLATLONGFORMAT(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setGEOLATLONGFORMAT(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getGEOLATLONGFORMAT()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getGEOLATLONGFORMAT(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setGEOMARKERVISIBILITY(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setGEOMARKERVISIBILITY(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getGEOMARKERVISIBILITY()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getGEOMARKERVISIBILITY(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPREVIEWTYPE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPREVIEWTYPE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getPREVIEWTYPE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getPREVIEWTYPE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setEXPORTMODELSPACE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setEXPORTMODELSPACE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getEXPORTMODELSPACE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getEXPORTMODELSPACE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setEXPORTPAPERSPACE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setEXPORTPAPERSPACE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getEXPORTPAPERSPACE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getEXPORTPAPERSPACE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setEXPORTPAGESETUP(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setEXPORTPAGESETUP(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getEXPORTPAGESETUP()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getEXPORTPAGESETUP(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFRAME(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setFRAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getFRAME()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getFRAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPDFFRAME(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPDFFRAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getPDFFRAME()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getPDFFRAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setXCLIPFRAME(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setXCLIPFRAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getXCLIPFRAME()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getXCLIPFRAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setMESHTYPE(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setMESHTYPE(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getMESHTYPE()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getMESHTYPE(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setSKYSTATUS(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setSKYSTATUS(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getSKYSTATUS()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getSKYSTATUS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual long getREQUIREDVERSIONS()
		{
			long result = TD_DbPINVOKE.OdDbDatabase_getREQUIREDVERSIONS(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCETRANSPARENCY(OdCmTransparency var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCETRANSPARENCY(this.swigCPtr, OdCmTransparency.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmTransparency getCETRANSPARENCY()
		{
			OdCmTransparency result = new OdCmTransparency(TD_DbPINVOKE.OdDbDatabase_getCETRANSPARENCY(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCVIEWDETAILSTYLE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCVIEWDETAILSTYLE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCVIEWDETAILSTYLE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCVIEWDETAILSTYLE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCVIEWSECTIONSTYLE(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setCVIEWSECTIONSTYLE(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId getCVIEWSECTIONSTYLE()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_getCVIEWSECTIONSTYLE(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setWIPEOUTFRAME(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setWIPEOUTFRAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getWIPEOUTFRAME()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getWIPEOUTFRAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPOINTCLOUDCLIPFRAME(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setPOINTCLOUDCLIPFRAME(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short getPOINTCLOUDCLIPFRAME()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_getPOINTCLOUDCLIPFRAME(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimadec(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimadec(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimadec()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimadec(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimalt(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimalt(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimalt()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimalt(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltd(ushort var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaltd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort dimaltd()
		{
			ushort result = TD_DbPINVOKE.OdDbDatabase_dimaltd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltf(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaltf(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimaltf()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimaltf(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltrnd(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaltrnd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimaltrnd()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimaltrnd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimalttd(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimalttd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimalttd()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimalttd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimalttz(byte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimalttz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimalttz()
		{
			byte result = TD_DbPINVOKE.OdDbDatabase_dimalttz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltu(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaltu(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimaltu()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimaltu(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltz(byte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaltz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimaltz()
		{
			byte result = TD_DbPINVOKE.OdDbDatabase_dimaltz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimapost(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimapost(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimapost()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_dimapost(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimasz(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimasz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimasz()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimasz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimatfit(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimatfit(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimatfit()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimatfit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaunit(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaunit(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimaunit()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimaunit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimazin(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimazin(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimazin()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimazin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimblk(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimblk(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimblk()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDatabase_dimblk(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimblk1(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimblk1(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimblk1()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDatabase_dimblk1(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimblk2(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimblk2(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimblk2()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDatabase_dimblk2(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimcen(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimcen(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimcen()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimcen(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimclrd(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimclrd(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimclrd()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDatabase_dimclrd(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimclre(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimclre(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimclre()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDatabase_dimclre(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimclrt(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimclrt(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimclrt()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDatabase_dimclrt(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdec(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimdec(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimdec()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimdec(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdle(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimdle(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimdle()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimdle(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdli(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimdli(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimdli()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimdli(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdsep(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimdsep(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimdsep()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimdsep(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimexe(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimexe(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimexe()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimexe(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimexo(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimexo(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimexo()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimexo(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimfrac(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimfrac(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimfrac()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimfrac(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimgap(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimgap(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimgap()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimgap(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimjust(ushort var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimjust(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort dimjust()
		{
			ushort result = TD_DbPINVOKE.OdDbDatabase_dimjust(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimldrblk(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimldrblk(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimldrblk()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDatabase_dimldrblk(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlfac(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimlfac(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimlfac()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimlfac(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlim(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimlim(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimlim()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimlim(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlunit(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimlunit(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimlunit()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimlunit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlwd(LineWeight var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimlwd(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LineWeight dimlwd()
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbDatabase_dimlwd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlwe(LineWeight var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimlwe(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LineWeight dimlwe()
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbDatabase_dimlwe(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimpost(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimpost(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimpost()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_dimpost(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimrnd(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimrnd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimrnd()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimrnd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsah(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimsah(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsah()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimsah(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimscale(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimscale(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimscale()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimscale(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsd1(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimsd1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsd1()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimsd1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsd2(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimsd2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsd2()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimsd2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimse1(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimse1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimse1()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimse1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimse2(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimse2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimse2()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimse2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsoxd(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimsoxd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsoxd()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimsoxd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtad(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtad(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtad()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimtad(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtdec(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtdec(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtdec()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimtdec(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtfac(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtfac(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtfac()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimtfac(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtih(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtih(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtih()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimtih(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtix(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtix(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtix()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimtix(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtm(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtm(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtm()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimtm(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtmove(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtmove(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtmove()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimtmove(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtofl(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtofl(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtofl()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimtofl(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtoh(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtoh(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtoh()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimtoh(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtol(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtol(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtol()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimtol(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtolj(byte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtolj(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimtolj()
		{
			byte result = TD_DbPINVOKE.OdDbDatabase_dimtolj(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtp(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtp(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtp()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimtp(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtsz(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtsz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtsz()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimtsz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtvp(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtvp(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtvp()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimtvp(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtxsty(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtxsty(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimtxsty()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_dimtxsty(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtxt(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtxt(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtxt()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimtxt(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtzin(byte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtzin(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimtzin()
		{
			byte result = TD_DbPINVOKE.OdDbDatabase_dimtzin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimupt(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimupt(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimupt()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimupt(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimzin(byte var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimzin(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimzin()
		{
			byte result = TD_DbPINVOKE.OdDbDatabase_dimzin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimfxl(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimfxl(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimfxl()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimfxl(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimfxlon(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimfxlon(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimfxlon()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimfxlon(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimjogang(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimjogang(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimjogang()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimjogang(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtfill(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtfill(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtfill()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimtfill(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtfillclr(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtfillclr(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimtfillclr()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDatabase_dimtfillclr(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimarcsym(short var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimarcsym(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimarcsym()
		{
			short result = TD_DbPINVOKE.OdDbDatabase_dimarcsym(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimltype(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimltype(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimltype()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_dimltype(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimltex1(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimltex1(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimltex1()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_dimltex1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimltex2(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimltex2(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimltex2()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDatabase_dimltex2(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtxtdirection(bool var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimtxtdirection(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtxtdirection()
		{
			bool result = TD_DbPINVOKE.OdDbDatabase_dimtxtdirection(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimmzf(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimmzf(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimmzf()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimmzf(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimmzs(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimmzs(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimmzs()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_dimmzs(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltmzf(double var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaltmzf(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimaltmzf()
		{
			double result = TD_DbPINVOKE.OdDbDatabase_dimaltmzf(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltmzs(string var)
		{
			TD_DbPINVOKE.OdDbDatabase_setDimaltmzs(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimaltmzs()
		{
			string result = TD_DbPINVOKE.OdDbDatabase_dimaltmzs(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private object locker = new object();

		private HandleRef swigCPtr;
	}
}
